var token = uni.getStorageSync('token')
// uni.getStorage({     
// 		key:'token',
// 		success(res) {
// 			console.log('获取成功',res.data);
// 		}
// 	})
// console.log(token,'靠靠靠靠靠靠靠')
// var url = 'http://api.wonewoo.com/'
// var url = 'http://38.181.24.233:18080/'
var url = 'https://api.wonevip.com/'

// 首页
export function getHomeData(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/index',
		method: 'GET',
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 获取收款地址
export function Moteygetaddress(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/getaddress',
		method: 'GET',
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 获取密码
export function passwordOne(successCallback, errorCallback) {
	uni.request({
		url: url + '/api/index/password',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 提交密码
export function passwordTwo(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/password',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			password: params.password,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);

				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// wooK折线图
export function wooKentins(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/woo_k',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 新闻资讯
export function articleData(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/article?id=' + params.id,
		method: 'GET',
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 获取提现金额
export function withdrawalGet(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/withdrawal',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// 提现
export function withdrawalPost(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/withdrawal',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			usdt: params.usdt,
			// password:params.password,
			sign: params.sign,
			time: params.time,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);

				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				uni.showToast({
					title: data.msg, // 提示内容为请求返回的msg
					icon: 'error'
				})
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 充值回调接口
export function Recharge(params, successCallback, errorCallback) {
	console.log(params);
	uni.request({
		url: url + 'api/index/recharge',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			// account:params.account,
			// password:params.password,
			hash: params.hash,
			usdt: params.usdt,
			type: params.type,
			time: params.timestamp,
			sign: params.signature,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);

				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 转大数
export function zhuanShu(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/zhuan',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			usdt: params.usdt,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);

				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 登录
// api/user/login
export function getLogin(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/login',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			// account:params.account,
			// password:params.password,
			url: params.url,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);

				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
// WONE的交易记录
export function WoneLog(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/wone_log',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			all: params.all,
			page: params.page
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 钱包
export function getMoney(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/money',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 钱包详情
export function getBonus(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/bonus',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			type: params.type,
			page: params.page
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 五倍专区转换准备页
export function getWealth(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/wealth',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 兑换五倍专区的商品确认操作
export function getExchange(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/exchange',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			usdt: params.usdt,
			password: params.password,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 配额确认
export function getPayWone(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/pay_wone',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			usdt: params.usdt,
			password: params.password
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 配额准备页
export function getPay(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/pay_wone',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 购买节点准备页
export function getPayNode(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/pey_node',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);

				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 购买节点会员
export function getPayNodeBtn(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/pey_node',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			node: params.node,
			password: params.password
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 节点会员
export function getMember(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/member_node',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					// uni.showToast({
					// 	 title: data.msg, // 提示内容为请求返回的msg
					// 	icon: 'error'
					// })
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 我的团队
export function getMyteam(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/myteam',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			page: params.page
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 我的钱包交易明细
export function getUsdt(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/usdt',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			all: params.all,
			coin: params.coin,
			page: params.page,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 获取闪兑参数
export function getFlash(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/flash',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 闪兑wone操作
export function getFlashBtn(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/flash',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			wone: params.wone,
			password: params.password,
			time: params.time,
			sign: params.sign,
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

// 质押明细
export function getPledge(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/pledge',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			page: params.page
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 绑定上级推荐人
export function getBind(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/bind',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {
			url: params.url
		},
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				console.log('请求成功', data);
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data.data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}
//获取推荐人ID
export function getUser(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/get_user',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			console.log(res, 'datafghj');
			// if (res.statusCode === 200) {
			let data = res.data;
			console.log('请求成功', data);
			if (data.code == 1) {
				// 请求成功，调用成功回调函数并传递数据
				successCallback(data);
			} else {
				// 请求成功，但接口返回的code不为1，表示请求处理失败
				errorCallback(data.msg);
				uni.showToast({
					title: data.msg, // 提示内容为请求返回的msg
					icon: 'error'
				})
			}
			// } else {
			// 请求失败
			// errorCallback('请求失败：' + res.statusCode);
			// console.log('请求失败',res.statusCode);
			// }
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

//获取自己资料
export function getMYsix(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/get_my',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			// if (res.statusCode === 200) {
			let data = res.data;
			// console.log('请求成功',data);
			if (data.code == 1) {
				// 请求成功，调用成功回调函数并传递数据
				successCallback(data);
			} else {
				// 请求成功，但接口返回的code不为1，表示请求处理失败
				errorCallback(data.msg);
			}
			// } else {
			// 请求失败
			// errorCallback('请求失败：' + res.statusCode);
			// console.log('请求失败',res.statusCode);
			// }
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}

export function getBalance(successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/getBalance',
		method: 'GET',
		header: {
			token: uni.getStorageSync('token')
		},
		data: {

		},
		success: function(res) {
			// if (res.statusCode === 200) {
			let data = res.data;
			// console.log('请求成功',data);
			if (data.code == 1) {
				// 请求成功，调用成功回调函数并传递数据
				successCallback(data);
			} else {
				// 请求成功，但接口返回的code不为1，表示请求处理失败
				errorCallback(data.msg);
			}
			// } else {
			// 请求失败
			// errorCallback('请求失败：' + res.statusCode);
			// console.log('请求失败',res.statusCode);
			// }
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 充值记录
export function getRechargeList(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/getRechange',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: params,
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 提现记录
export function getWithList(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/getWithList',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: params,
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}


// 获取最大入金数量
export function gettodaymoney(params, successCallback, errorCallback) {
	uni.request({
		url: url + 'api/index/gettodaymoney',
		method: 'POST',
		header: {
			token: uni.getStorageSync('token')
		},
		data: params,
		success: function(res) {
			if (res.statusCode === 200) {
				let data = res.data;
				if (data.code === 1) {
					// 请求成功，调用成功回调函数并传递数据
					successCallback(data);
				} else {
					// 请求成功，但接口返回的code不为1，表示请求处理失败
					errorCallback(data.msg);
					uni.showToast({
						title: data.msg, // 提示内容为请求返回的msg
						icon: 'error'
					})
				}
			} else {
				// 请求失败
				errorCallback('请求失败：' + res.statusCode);
				console.log('请求失败', res.statusCode);
			}
		},
		fail: function(err) {
			// 网络请求失败
			errorCallback('网络请求失败：' + err);
		}
	});
}